|
Roy Longbottom's Android Benchmark Apps
|
|
Java Whetstone ResultsThe first measurements obtained were via emulators running on a 3 GHz quad core Phenom, the benchmark only using one core, of course. They suggest a slightly slower performance using a screen with a higher pixel density and much better performance with a later Android version and/or a more modern CPU. Based on comparisons with CPU MHz, v7-A8 CPUs are faster than the ARM 926EJ CPU, due to VFPv3 enhanced floating point hardware, and in turn, v7-A9s are even faster. Performance of P8, with the Qualcomm MSM8960 CPU, is superior to these ARM devices. Some of the v7-A9 resulrs are not proportional to CPU MHz, where calculations suggest that that 1300 MHz T7 and 1500 MHz T4 are running at 1200 MHz. This was confirmed later, using a new program. See Measure CPU MHz. August 2013 - Cortex-A15 based tablet T11 (really running at 1700 MHz) has the fastest speeds, at this time. On a per MHz basis, it outperforms Cortex-A9 by 30% to 40%, except on the mathematical function tests (headed COS and EXP) where performance is similar.
The last two sets of results are for the same Java code running on Intel CPUs under Linux and via Android x86.
These use different JIT compilers, voiding comparisons with the other Android results.
Java Numeric ResultsBoth emulated and real numeric results using ARMv7 are different from ARM926EJ for some floating point calculations. This is not unusual for different compilers or types of processor and is due to variations in instruction sequences or hardware rounding arrangements. It looks as though these two processors are not logically identical or program optimisation procesures are different.
ARMv7 P3 has enhanced architecture that probably changes the calculated results of the lasts test.
Results from Native Code versions are also provided.
|
System ARM MHz Android MWIPS ------MFLOPS------- ------------MOPS-------------- See CPU Build 1 2 3 COS EXP FIXPT IF EQUAL T1 @5 926EJ 800 2.2 31.2 10.2 10.2 11.4 0.6 0.3 38.8 278.4 219.4 T1 @7 926EJ 800 2.2 30.3 10.2 9.3 11.5 0.6 0.3 39.0 293.5 220.1 T2 @5 v7-A9 800 2.3.4 170.9 20.4 21.4 28.4 7.6 2.2 85.5 756.0 764.3 T2 @7 v7-A9 800 2.3.4 687.4 165.4 149.9 153.4 15.9 9.3 723.1 1082.1 725.3 T4 @7 v7-A9 1500a 4.0.3 1129.3 272.7 250.0 256.4 25.5 15.1 1197.5 1789.3 1190.7 T4 CPU Norm 1500 4.0.3 650.6 35.4 237.5 164.4 11.3 14.2 405.3 1468.9 1174.5 T4 CPU Norm 1500 4.0.3 203.1 46.2 90.7 53.8 3.9 2.7 221.6 199.1 472.3 T6 @7 v7-A9 1600 4.0.3 1514.6 350.3 330.9 339.2 35.0 20.5 1583.4 2355.5 1582.8 T7 @7 v7-A9 1300a 4.1.2 1115.0 271.3 250.7 256.4 25.8 14.6 1190.0 1797.0 1198.7 T11 @7 v7-A15 2000b 4.2.2 1477.7 363.9 220.6 307.5 39.7 18.0 1690.5 2527.9 1127.9 T13 @7 v7-A9 1400c 4.1.2 808.9 209.0 162.3 204.3 17.2 11.3 854.5 1273.2 906.6 T13 @7 v7-A9 1400 4.1.2 1180.6 303.5 283.5 264.3 28.8 14.4 1358.9 2998.2 1282.2 P8 @7 QU-S4 1500 4.0.3 1039.5 255.7 316.5 299.6 20.2 13.2 1503.6 1795.2 1504.2 P9 @7 v7-A8 1000 2.3.5 288.2 95.0 83.8 87.6 5.8 3.5 389.6 929.5 228.5 P11 @7 v7-A9 1400 4.0.4 1333.6 315.5 291.2 298.6 39.8 18.1 1394.7 2089.9 1395.5 Measured MHz a=1200, b=1700, c=power saving EP1 @5 926EJ Emul 2.2 20.1 7.0 6.7 9.3 0.4 0.2 30.9 218.6 98.5 ET2 @5 v7-A8 Emul 4.03 43.7 7.2 7.0 9.3 1.1 0.6 30.8 225.1 100.9 ET2 @7 v7-A8 Emul 4.03 96.7 37.0 32.1 36.1 1.6 1.3 121.9 238.4 216.4 BS1 Emul Ph 3000 2.3.4 103.6 36.9 32.6 37.7 1.8 1.4 130.2 414.0 374.1 Atom 1666 Linux 769.0 330.0 333.0 282.0 17.1 7.2 968.0 1143.0 1149.0 Core 2 2400 Linux 2560.0 865.0 885.0 589.0 65.7 29.1 3851.0 5314.0 1078.0 System - T = Tablet, P = Phone, E = Emulator, @7 for vfpv3 FPU, QU = Qualcomm CPU CPU Norm = ICS Settings, Developer Options, CPU Mode, Normal - other T4 = Performance |
Results are also shown for Linux C compilations on two Intel processors.
In this case, the A9 CPU at 1500 MHz has a better overall score than the 1666 MHz Atom. This is due to the faster tests using such as Cos and Exp functions.
Linpack 100 Benchmark

The Linpack Benchmark was produced from the "LINPACK" package of linear algebra routines. It became the primary benchmark for scientific applications, particularly under Unix, from the mid 1980's, with a slant towards supercomputer performance. The original double precision C version, used here, operates on 100x100 matrices. Performance is governed by an inner loop in function daxpy() with a linked triad dy[i] = dy[i] + da * dx[i], and is measured in Millions of Floating Point Operations Per Second (MFLOPS). Two versions use a Java front end, again providing Run, Info and Save buttons, with the main C code compiled by Android Native Development Kit. A third comprises the same front end with Java code for Linpack calculations. They are Linpackv5.apk (LP5), using old, slow instructions, Linpackv7.apk (LPK) to use faster vfpv3 hardware and LinpackJava.apk (LPJ) that depends on a suitable Runtime Environment. A fourth variety, LinpackSP.apk (LPsp) is also available, comprising the C version compiled to use single precision floating point. The .apk application files can be downloaded from:
www.roylongbottom.org.uk/Linpackv5.apk and www.roylongbottom.org.uk/LinpackJava.apk
www.roylongbottom.org.uk/Linpackv7.apk and www.roylongbottom.org.uk/LinpackSP.apk
Further details of the Linpack benchmark, and results from Windows and Linux based PCs, can be found in Linpack Results.htm. The Java version has the same calibration calculations as my C program but the uses the Code from Netlib for the calculations, as C uses different function calling conventions.
Output results provide the same System Information as shown for the Whetstone Benchmark, preceded by MFLOPS speed and numeric results, examples being shown below.
In this case, calculations from the double precision versions produce the same numeric results, with differences using single precision functions. These are also identical to those from Microsoft Visual C under Windows and Linux using 64-Bit GCC on PCs, with other compilers used producing differences.
Android Linpack v5 Benchmark Android Java Linpack Benchmark
Speed 10.56 MFLOPS Speed 33.36 MFLOPS
norm. resid 1.7 norm. resid 1.7
resid 7.41628980e-14 resid 7.41628980e-14
machep 2.22044605e-16 machep 2.22044605e-16
x[0]-1 -1.49880108e-14 x[0]-1 -1.49880108e-14
x[n-1]-1 -1.89848137e-14 x[n-1]-1 -1.89848137e-14
Same
Android Linpack v7 Benchmark Android Linpack v7SP Benchmark
Speed 101.39 MFLOPS Speed 129.05 MFLOPS
norm. resid 1.7 norm. resid 1.6
resid 7.41628980e-14 resid 3.80277634e-05
machep 2.22044605e-16 machep 1.19209290e-07
x[0]-1 -1.49880108e-14 x[0]-1 -1.38282776e-05
x[n-1]-1 -1.89848137e-14 x[n-1]-1 -7.51018524e-06
Same Different
Android x86 Java on Core 2 Android x86 Java on Atom
Speed 53.27 MFLOPS Speed 15.65 MFLOPS
norm. resid 1.8 norm. resid 1.8
resid 8.03801470e-14 resid 8.03801470e-14
machep 2.22044605e-16 machep 2.22044605e-16
x[0]-1 3.55271368e-14 x[0]-1 3.55271368e-14
x[n-1]-1 3.44169138e-14 x[n-1]-1 3.44169138e-14
Different Different
|
MFLOPS results for the four Android versions are provided below. Also shown are those for PCs, compiled for Windows and Linux, the benchmarks being downloadable via Linpack Results.htm. Java results for PCs were from using Linpack Java Applet from Netlib and Android x86.
The most popular Android Linpack benchmark appears to be from GreeneComputing. This is a Java variety and produces similar performance ratings to my LinpackJava on T1 and T2 as quoted below. The former also has a multi-processor test but it is not clear whether it uses multiple threads on a single program, or multiple copies of the program, where results and not really representative for comparing with published MP speeds.
Using compiled C programs a Cortex-A9 can be nearly as fast as an Atom running at the same MHz, but this is not the case with Java. Unlike Intel, it seems that the double precision version can be much slower than using single precision calculations.
The T4 and T7 v7-A9 CPUs again appear to be slow at 1200 MHz but T2, T6 and P11 seem to be at full speed. The Qualcomm CPU performs well on this benchmark.
August 2013 - Tablet T11, with the Cortex-A15 CPU, runs at 2.5 times the speed of an A9 processor of the same MHz (if one existed), using the most recent floating point instructions. Linpack benchmark results are often quoted for ARM based systems, probably a design consideration.
The benchmark code has been modified to use NEON intrinsic functions that carry out four arithmetic operations simultaneously. See
android neon benchmarks.htm . For the new benchmark
Download NEON-Linpack.apk.
Results from this are included below.
Dhrystone 2 Benchmark 
The Dhrystone "C" benchmark provides a measure of integer performance (no floating point instructions). It became the key standard benchmark from 1984, with the growth of Unix systems. The first version was produced by Reinhold P. Weicker in ADA and translated to "C" by Rick Richardson. Two versions are available - Dhrystone versions 1.1 and 2.1. The second version, used here, was produced to avoid over-optimisation problems encountered with version 1, but some is still possible. Because of this, optimised and non-optimised compilations are provided. Speed was originally measured in Dhrystones per second. This was later changed to VAX MIPS by dividing Dhrystones per second by 1757, the DEC VAX 11/780 result, the latter being regarded as the first 1 MIPS minicomputer.
The optimised .apk app file (DS2) can be downloaded from www.roylongbottom.org.uk/Dhrystone2.apk and the non-optimised one (DSN) from www.roylongbottom.org.uk/Dhry2Nopt.apk. Further details of the Dhrystone benchmark, and results from Windows and Linux based PCs, can be found in Dhrystone Results.htm.
The same format Java front end, described above, is used, with the two C programs compiled using Android NDK. Examples of results is below, the Emailed version including the standard System Information.
Dhrystone 2 Benchmark 10-Feb-2012 19.08 Dhry2 NoOpt Benchmark 14-Feb-2012 12.15 Nanoseconds one Dhrystone run 592 Nanoseconds one Dhrystone run 1244 Dhrystones per Second 1689546 Dhrystones per Second 804020 VAX MIPS rating 962 VAX MIPS rating 458 |
Unlike when using floating point, on this benchmark, the Cortex-A9 CPU is less than three times faster than the 926EJ on all measurements, a ratio similar to that provided by the BogoMIPS results, shown in System Information. Measurements for Intel Atom and Core 2 CPUs are also provided for Windows (Watcom 32 Bit) and Linux (GCC 32 Bit and 64 Bit) compilations. Core 2 results show considerable variations, highlighting the Danger, in comparing results from different compilers. In this case, the significant difference is between 32 and 64 bit compilations under Linux, where far more registers are available for optimisation at 64 bits. On using them, the compiler might decide that multiple passes are not needed and remove repetitive calculations. Also, historically, computer manufacturers are known to have optimised their own compilers to inflate speeds of standard benchmarks.
Here, the optimised benchmark produces up to 1.4 Vax MIPS/MHz for the Cortex-A9. ARM, themselves, quote 2.5 Vax MIPS (DMIPS) per MHz for the same processor, probably just another different compiler variation.
Note the speed on tablet T5. This uses a MIPS CPU and requires an emulator to execute compiled ARM processor instructions. T5a results are for an identical tablet, from a different user, but with no details of settings used. The T4 and T7 v7-A9 CPUs again appear to be slow at 1200 MHz but T2 and P11 seem to be at full speed.
August 2013 - Tablet T11, with the Cortex-A15, is 30% to 40% faster than would be expected from the last generation of ARM processors.
Below are other results from http://gamma0burst.tistory.com in Korea (including some of mine). These provide better identification of the processors used. There are wide variations in results of what should be identical CPUs but, as with all benchmarks reported here, the systems might not be running at the specified clock frequency or might need a Setting to run at maximum speed.
Opt No Opt
System ARM MHz Android Vax Vax Bogo
See MIPS MIPS MIPS
T1 926EJ 800 2.2 356 196 798
T2 v7-A9 800 2.3.4 962 458 2036
P13 v7-A9 1200 4.1.2 1491 1592
P14 v7-A93 ? 4.2.3 645 2000
T4 v7-A9 1500a 4.0.3 1650 786 2394
T7 v7-A9 1300a 4.1.2 1610 810 1994
T11 v7-A15 2000b 4.2.2 3189 1504 998
P11 v7-A93 1400 4.0.4 1937 866 2786
EP1 926EJ Emul 2.2 227 122
ET2 v7-A8 Emul 4.03 286 160
Measured MHz a=1200, b=1700
T5 MIPS CPU 1000 4.01 56 1006
T5a MIPS CPU 1000 4.01 213 1006
T5a MIPS CPU 1000 4.01 70 1006
BS1 Emul Ph 3000 2.3.4 484
BS2 Emul C2 1833 2.3.4 150
32 Bit Atom 1666 Linux 2055 1194
64 Bit Atom 1666 Linux 2704 1098
32 Bit Atom 1666 Windows 1948 780
32 Bit Core 2 2400 Linux 5852 3348
64 Bit Core 2 2400 Linux 12265 3288
32 Bit Core 2 2400 Windows 6466 1251
System - T = Tablet, P = Phone, E = Emulator
Processor MHz Cores VAX MIPS
MIPS /MHz
Sam Exynos 4210 Cortex-A9 1200 2 1491 1.24
1200 2 1900 1.58
1400 2 1450 1.04
Sam Exynos 4412 Cortex-A9 1400 4 1740 1.24
1400 4 1937 1.38
Aml AML 8726-MX Cortex-A9 1500 2 1650 1.10
TI OMAP 4430 Cortex-A9 1200 2 1409 1.17
1200 2 1662 1.39
nV Tegra 3 Cortex-A9 1300 4 1610 1.24
Sam Exynos 5250 Cortex-A15 1700 2 3200 1.88
1700 2 3687 2.17
QSn S1 QSD 8250 Scorpian 1000 1 880 0.88
QSn S4 APQ 8064 Krait 1500 4 2417 1.61
1500 4 2555 1.70
QSn S4 APQ 8064T Krait 1700 4 2563 1.51
QSn S4 MSM 8960 Krait 1500 2 2229 1.49
QSn - Qualcomm Snapdragon, Sam - Samsung, Aml - Amlogic,
Ti - Texas Instruments, nV - nVidia
|
Livermore Loops BenchmarkThis original main benchmark for supercomputers was first introduced in 1970, initially comprising 14 kernels of numerical application, written in Fortran. This was increased to 24 kernels in the 1980s. Performance measurements are in terms of Millions of Floating Point Operations Per Second or MFLOPS. The kernels are executed three times with different double precision data array sizes. Following are overall MFLOPS results for various systems, geometric mean being the official average performance. [Reference - F.H. McMahon, The Livermore Fortran Kernels: A Computer Test Of The Numerical Performance Range, Lawrence Livermore National Laboratory, Livermore, California, UCRL-53745, December 1986]
---------------- MFLOPS ---------------
CPU MHz Maximum Average Geomean Harmean Minimum Measured in
CDC 6600 10 1.1 0.5 0.5 0.4 0.2 1970 *
CDC 7600 36.4 7.3 4.2 3.9 2.5 1.4 1974 *
Cray 1A 80 83.5 25.8 14.4 7.9 2.7 1980 *
Cray 1S 80 82.1 22.2 11.9 6.5 1.0 1985
CDC Cyber 205 50 146.9 36.4 14.6 5.0 0.6 1982 *
Cray 2 244 146.4 36.7 14.2 5.8 1.7 1985
Cray XMP1 105 187.8 61.3 31.5 15.6 3.6 1986
* Fewer than 24 Kernels
For Cray 1 comparison purposes, it is more appropriate to use Cray 1S results, as these are from running all 24 kernels. See below for best results so far, currently T4 using one of the two 1500 MHz cores, where performance equates to 15.5 times a Cray 1. Cost of this tablet was $130, in May 2012. Cray 1 was $7M.
The benchmark execution file can be downloaded from www.roylongbottom.org.uk/LivermoreLoops.apk. Further details of the Livermore Loops benchmark, and results from Windows and Linux based PCs, can be found in Livermore Loops Results.htm.
The same format Java front end, described above, is used, with the C program compiled using Android NDK. An example of results is below, the Emailed version including the standard System Information.
800 MHz ARM Cortex-A9
Android Livermore Loops Benchmark 12-Feb-2012 21.55
MFLOPS for 24 loops Do Span 471
172.6 127.5 253.2 248.6 71.6 141.2
197.6 190.4 202.3 109.2 55.2 51.2
54.1 51.5 100.0 144.1 192.1 139.4
130.1 105.4 111.2 63.1 136.3 56.8
Overall Weighted MFLOPS Do Spans 471, 90, 19
Maximum Average Geomean Harmean Minimum
253.2 129.3 115.3 101.6 46.7
Results of last two calculations
4.850340602749970e+02 1.300000000000000e+01
Total Elapsed Time 11.9 seconds
|
So far, numeric results of the last two calculations have been identical on all benchmark runs.
System T2, with the high speed vfpv3 hardware, is again shown to be around 20 times faster than the tablet T1, on these floating point calculations. Relative to CPU MHz, T2 performs better than v7-A9 CPUs T4 and T7 and P8 Qualcomm, but P11 outshines them all. This benchmark has some L2 cache speed dependency. This cache is shown to be particularly fast on later benchmarks.
August 2013 - again, it is pointed out that tablet T11, with the Cortex-A15, is really running at 1700 MHz (not 2000), and some Cortex-A9s, used for comparison, are at 1200 MHz. This A15 is the first ARM processor to demonstrate more than 1 GFLOPS, on this benchmark. On a per MHz basis, the results demonstrate a wide range of relativity to A9s, varying from slighly slower to 3.4 times faster, the official average showing an improvement of 50%. Then, the system is also running at a higher MHz.
This benchmark is one of those that failed to use fast vfpv3 hardware under Android 4, Ice Cream Sandwich. In this case, a revised compilation procedure lead to the hardware being used with appropriate faster performance. The procedure was to compile a program that used vfpv3, then replace the Java and C code with that for the benchmark (see below).
MemSpeed BenchmarkThis benchmark measures data reading speeds in MegaBytes per second carrying out calculations on arrays of cache and RAM data, sized 2 x 8 KB to 2 x 32 MB. Calculations are x[m]=x[m]+s*y[m] and x[m]=x[m]+y[m], using double and single precision floating point and x[m]=x[m]+s+y[m] and x[m]=x[m]+y[m] with integers. Million Floating Point Operations Per Second (MFLOPS) speed can be calculated by dividing double precision MB/second by 8 and 16, for the two tests, and single precision speeds by 4 and 8. Assembly listings for integer tests show that Millions of Instructions Per Second (MIPS) can be found by multiplying MB/second by 0.78 with 2 adds and 0.66 for the other test. Cache sizes are indicated by varying performance as memory usage changes.
Results below show maximum MFLOPS and MIPS speeds. The first integer test loop has 25 assembler type instructions, comprising 8 loads (x 4 bytes), 11 adds (8 data, 2 addresses, 1 loop increment), 4 stores, 1 compare, 1 branch), or an instructions/bytes ratio of 0.78125. Best Cortex-A9 MIPS/MHz ratio is 1.59.
Using L1 cache data, performance differences on Cortex CPUs are similar to the benchmarks above. In the case of the Qualcomm Snapdragon, floating point tests are significantly faster, relative to CPU MHz, but a little slower using integers. Other than comparisons with the Snapdragon CPU, P11, the Galaxy SIII, provides a significant performance gain using L2 cache. This might be due to the claimed use of 128-bit internal buses, instead of 64-bit. The most outstanding results for P11 are using memory, typically three times faster than other A9s, and these might be aided by the L2 cache arrangement. P11 is said to have dual channel memory and, although not always stated, others have a single channel (see Memory and Bus Speed Calculations below).
August 2013 - T11, with the Cortex-A15, provides the fastest speeds reported here. Again, more than 1 GFLOPS is demonstrated, but this time with single precision calculations. Compared with P11, the last leader, and adjusting to compare at the same clock speed, memory speeds are similar, but the T11 is 2 to 3 times faster on double precision calculations, 3 to 4 times at single precision and 1.5 to twice as fast with integers. This A15 obtains 1.8 MIPS/MHz.
The app can be downloaded from
www.roylongbottom.org.uk/MemSpeed.apk.
The program code used is the same as
Linux Multithreading Benchmarks.htm
and (nearly)
MemSpd2k Results.htm.
Results on an Intel Atom, for a single thread, using the multithreading benchmark, are shown below. On a per MHz basis, the Cortex-A9 performs well using L1 cache, comapared with the Atom but not always so with RAM based data.
Except for certain RAM tests, the Cortex-A15's performance is significantly better than the Atom.
T1, ARM 926EJ 800 MHz, Android 2.2, DDR2 RAM
Android MemSpeed Benchmark 17-Feb-2012 17.47
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 60 44 600 93 76 694
32 46 38 146 60 56 146
64 48 37 154 66 54 144
128 48 36 155 65 53 144
256 48 36 153 65 56 135
512 48 38 153 65 57 142
1024 47 37 153 65 57 142
4096 47 37 152 67 55 142
16384 47 37 152 70 63 138
65536 44 37 153 106 92 142
Total Elapsed Time 93.5 seconds
Maximum SP MFLOPS 11 Integer MIPS 468
T2, ARM Cortex-A9 800 MHz, Android 2.3.4 DDR2 RAM
Android MemSpeed Benchmark 17-Feb-2012 17.41
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 1002 533 1574 1742 812 1639
32 1042 530 1533 1717 701 1751
64 994 461 984 1144 644 942
128 656 396 691 696 511 673
256 269 259 273 271 255 280
512 249 246 244 256 244 247
1024 249 249 244 240 253 244
4096 246 244 247 246 242 245
16384 253 236 252 254 241 246
65536 254 241 253 250 252 241
Total Elapsed Time 19.4 seconds
Maximum SP MFLOPS 133 Integer MIPS 1228
T4, ARM Cortex-A9 1500 MHz, Android 4.0.3 DDR3 RAM
Measured 1200 MHz
Android MemSpeed Benchmark 11-May-2012 17.00
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 1631 834 2425 2700 1353 2799
32 1585 823 1863 2105 1185 2060
64 1265 724 1266 1532 982 1369
128 1311 715 1243 1480 963 1318
256 1229 697 1209 1295 938 1284
512 1044 579 1004 1203 680 1009
1024 473 405 474 482 430 474
4096 413 387 419 408 389 424
16384 410 386 423 408 382 422
65536 405 371 419 397 384 418
Total Elapsed Time 12.9 seconds
Maximum SP MFLOPS 209 Integer MIPS 1892
T7, ARM Cortex-A9 1300 MHz, Android 4.1.2, 1 GB DDR3 RAM
Measured 1200 MHz
Android MemSpeed Benchmark 17-Oct-2012 20.19
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 1735 888 2456 2726 1364 2818
32 1448 760 1474 1700 1039 1648
64 1318 719 1290 1468 952 1385
128 1279 715 1289 1443 944 1336
256 1268 714 1279 1435 943 1313
512 1158 691 1204 1321 892 1228
1024 729 553 735 772 632 742
4096 445 392 425 442 421 439
16384 435 390 428 435 412 431
65536 445 404 393 450 432 449
Total Elapsed Time 12.2 seconds
Maximum SP MFLOPS 222 Integer MIPS 1916
T8 Allwinner A13-MID, 1 GHz ARM Cortex-A8
Android MemSpeed Benchmark 1.1 05-Mar-2013 10.01
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 293 124 1376 481 241 1439
32 296 119 1389 482 230 1646
64 220 86 783 345 241 1301
128 288 122 1081 475 224 1288
256 233 106 462 315 197 513
512 188 98 256 247 168 276
1024 185 95 214 249 162 233
4096 183 98 228 248 163 236
16384 174 96 228 234 163 234
65536 183 98 206 243 155 214
Total Elapsed Time 29.8 seconds
Maximum SP MFLOPS 31 Integer MIPS 1075
T9 ARM 926EJ 800 MHz, Android 2.2
Android MemSpeed Benchmark 1.1 09-jul-2013 22.59
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 52 36 510 61 67 579
32 41 30 129 52 48 129
64 35 33 133 54 47 125
128 41 25 126 58 47 124
256 43 31 134 53 49 119
512 43 35 154 65 56 144
1024 47 38 153 65 56 146
4096 48 38 153 67 58 144
16384 43 37 152 73 63 144
65536 47 37 152 106 92 146
Total Elapsed Time 102,2 seconds
Maximum SP MFLOPS 11 Integer MIPS 398
T11 Samsung EXYNOS 5250 2000 MHz Cortex-A15, Android 4.2.2
Measured 1700 MHz
Android MemSpeed Benchmark 1.1 09-Aug-2013 17.04
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 7296 4159 3513 9375 5453 6211
32 7253 4540 3882 7364 4873 4839
64 6902 4265 3878 7026 4373 4274
128 6735 4032 2480 4005 2797 3288
256 5859 3775 2192 4527 3263 3676
512 5795 3781 3568 6282 3819 3818
1024 2609 1757 1754 2607 1805 1825
4096 1614 1422 1471 1654 1342 1441
16384 1624 1412 1474 1642 1336 1443
65536 1617 1408 1479 1368 1321 1423
Total Elapsed Time 10.7 seconds
Maximum SP MFLOPS 1135 Integer MIPS 3028
P6, Qualcomm S4 1500 MHz, Android 4.0.3, 1 GB DDR2 RAM
Android MemSpeed Benchmark 07-Jun-2012 09.45
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 2564 1428 1600 3697 1947 1894
32 2003 1381 1006 2432 1489 1118
64 1864 1284 1011 2378 1448 834
128 1868 1289 1004 2343 1431 1110
256 1865 1288 1010 2379 1442 1117
512 1853 1274 1004 2372 1429 1115
1024 855 731 658 941 782 694
4096 674 604 553 731 642 556
16384 668 605 554 730 640 585
65536 672 602 557 728 639 590
Total Elapsed Time 10.6 seconds
Maximum SP MFLOPS 357 Integer MIPS 1248
P8 Qualcomm Snapdragon, 1.5 GHz, Android 4.0.3, DDR2
Android MemSpeed Benchmark 10-Jul-2012 22.10
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 3636 2162 2509 4782 3181 2796
32 3109 1900 1512 3823 2330 1725
64 2931 1792 1514 3744 2277 1717
128 2927 1809 1512 3747 2276 1723
256 2920 1817 1506 3732 2269 1716
512 2320 1581 1345 2753 1894 1497
1024 1101 934 859 1161 1000 884
4096 902 823 766 965 830 777
16384 923 818 754 957 829 774
65536 926 821 754 957 827 776
Total Elapsed Time 10.4 seconds
Maximum SP MFLOPS 541 Integer MIPS 1957
P10 Qualcomm Snapdragon, 1.5 GHz, Android 4.0.3, DDR2
Android MemSpeed Benchmark 25-Sep-2012 09.05
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 3048 2203 2559 5452 3168 2784
32 2823 1720 1504 3827 2328 1723
64 2662 1787 1505 3793 2269 1716
128 2654 1812 1511 3800 2235 1717
256 2812 1808 1505 3793 2280 1709
512 2343 1580 1336 2833 1875 1496
1024 1177 966 876 1245 1012 916
4096 802 785 730 910 779 750
16384 882 722 729 913 791 745
65536 873 732 722 906 645 744
Total Elapsed Time 10.8 seconds
Maximum SP MFLOPS 550 Integer MIPS 1996
P11 ARM Cortex-A9 1.4 GHz, Android 4.0.4, DCDDR2
Android MemSpeed Benchmark 23-Dec-2012 15.16
Reading Speed in MBytes/Second
Memory x[m]=x[m]+s*y[m] Int+ x[m]=x[m]+y[m]
KBytes Dble Sngl Int Dble Sngl Int
16 983 926 2849 3162 1578 3265
32 1825 911 1694 2084 949 1892
64 1810 894 1654 1999 1174 1659
128 1816 867 1599 1945 1168 1758
256 1813 870 1596 1931 1162 1765
512 1802 868 1570 1779 1098 1740
1024 1569 828 1474 1776 1110 1634
4096 1362 817 1105 1310 1066 1335
16384 1287 825 1304 1338 926 1319
65536 1319 824 1298 1294 1072 1284
Total Elapsed Time 12.0 seconds
Maximum SP MFLOPS 231 Integer MIPS 2222
Atom 1666 MHz, DDR2 RAM 800 MHz, Linux
16 1892 943 1979 2759 1329 2813
64 1647 879 1690 2334 1269 2323
65535 1515 834 1517 2010 1208 1945
|
Some assumptions regarding memory and bus speeds are aired here, based on knowledge provided for mainstream PCs, Google searches and results below. Whereas PC memory bus width is 8 bytes (per channel), that for these ARM systems is 4 bytes or less, considerably reducing relative maximum memory data transfer speeds.
As with PCs, data is read in bursts and this is normally clear from BusSpeed results, from which maximum data transfer speeds can be estimated. Suggested burst size for System T1 is 8 words or 32 bytes with maximum speed of 29 x 8 or 232 MB/second. For T2 and T4, 16 byte bursts are suggested with maximum speed between 35 x 16 to 39 x 16 or 560 to 624 MB/second. One reason for not achieving this performance is startup delays (CAS Latency - number of bus clocks).
It seems to be extremely difficult to obtain details of bus speeds and channel/bus configurations for Android devices. T7 appears to have single channel, double data rate 1333 MHz RAM, where maximum speed would be 666.7 (clock MHz) x 2 (DDR) x 4 (32 bit wide bus) = 5.33 GB/second. Then P11, with dual channel, DDR 1066 MHz RAM, could produce 533 x 2 x 2 (channels) x 4 = 8.53 GB/second. Speed estimated from burst tests and real measurements are nowhere near these maximum speeds but can be much faster using the MultiThreading Benchmark version.
There are startup delays on transferring bursts of data, usually associated with the number of bus clocks under the heading of CAS Latency. With DDR, a one clock overhead can reduce data transfer rate by 33%. Measured maximum speed reading all data can also be much lower than that derived from burst reading tests, due to various internal processor delays. For examples see the AndI 2Reg and AndI 1Reg) in
BusSpd2K Memory Speed Results.
BusSpeed Benchmark 
This benchmark is designed to identify reading data in bursts over buses. The program starts by reading a word (4 bytes) with an address increment of 32 words (128 bytes) before reading another word. The increment is reduced by half on successive tests, until all data is read. On reading data from RAM, 64 Byte bursts are typically used. Then, measured reading speed reduces from a maximum, when all data is read, to a minimum on using 16 word increments (64 bytes). Potential maximum speed can be estimated by multiplying this minimum value by 16. With this burst rate, measured speed at 32 word and 16 word increments are likely to be the same. Cache sizes are indicated by varying speed as memory use changes. Note, with smallest L1 cache demands, measured speed can be low due to overheads when reading little data.
The program C source code is as used for Linux, See BusSpd2K Results.htm. This has unrolled loops with up to 64 AND statements (& array[i ] to & array[i+63]). The Linux compiler for Intel CPUs translates this into 64 assembly instructions ANDing data from indexed memory locations. In this case, Integer MIPS approximately equals MB/second divided by 4. The Android NDK compiler generates 133 assembler type instructions, including 64 loads and 64 ANDs, where MIPS equates to MB/second divided by 1.92 (64 x 4 / 133) - twice as many instructions as Intel. Maximum MIPS and MIPS/MHz details have been added to the results below.
With data from L1 cache, tablets T4 and T7 again produce lower performance than might be expected, compared with CPU MHz with T6 better, compared with P11. The Qualcomm Snapdragon results are also on the low side, and it appears to have burst reading from L1 cache, with much lower data transfer speeds with the highest incremented addressing. As with MemSpeed, the upgraded Cortex-A9 CPU in P11 provides significant performance gains using L2 cache and RAM. Unlike using L1 cache, the Qualcomm CPU provides superior performance at high address increments.
August 2013 - T11, with the EXYNOS running at 1700 MHz, produces the best integer performance so far, or a maximum of 3224 MIPS or 1.9 MIPS per MHz. This can be compared with P11 Cortex-A9 at 1400 MHz, that reaches 2205 MIPS or 1.6 MIPS per MHz. T11’s L2 cache is even more efficient at twice the speed of P11, after adjusting for the same CPU MHz.
The original benchmark application can be downloaded from
www.roylongbottom.org.uk/BusSpeed.apk.
and the Android 4 version from
www.roylongbottom.org.uk/BusSpeedv7.apk.
Randmem BenchmarkRandMem benchmark carries out four tests at increasing data sizes to produce data transfer speeds in MBytes Per Second from caches and memory. Serial and random address selections are employed, using the same program structure, with read and read/write tests using 32 bit integers. The main purpose is to demonstrate how much slower performance can be through using random access. Here, speed can be considerably influenced by reading and writing in bursts, where much of the data is not used, and by the size of preceding caches.
The benchmark uses the first four tests described in RandMem Results.htm and can be downloaded from www.roylongbottom.org.uk/RandMem.apk. The program structure is as follows, with array xi indexing via sequential or random numbers stored in the array.
Read - toti = toti & xi[xi[i+0]] | xi[xi[i+2]
& xi[xi[i+4]] | xi[xi[i+4]] and &| to i+30
Read/write - xi[xi[i+2]] = xi[xi[i+0]];
xi[xi[i+6]] = xi[xi[i+4]]; repeated to i+30 and i+28
The results below show that random access performance is approximately the same as BusSpeed with address increments of 32 words, the burst reading effect. This program is again based on indexed memory addressing where the older technology CPU can be faster than than the System T2. This might be due to poor implementation of the memory bus interface on this tablet, as noted on PC tests. Atom results are provided, again showing better relative performance, particularly when using data from RAM. As with BusSpeed, and not noticed so far on the other benchmarks, measured speeds using L1 cache are sometimes slow to start with.
Relative performance of Cortex CPUs is similar to the other memory tests. The Qualcomm Snapdragon performs very well on random access to L2 cache and RAM, repeating the effects of faster burst reading speed seen in BusSpeed.
August 2013 - Cortex-A15 based T11 again come out fastest at this time. Best comparative performance is for data using L2 cache, particularly with serial reading. where RAM speed comparisons are also good.
System T1, ARM 926EJ 800 MHz, Android 2.2
Android RandMem Benchmark 20-Feb-2012 16.51
MBytes/Second transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 841 1119 666 955
32 222 147 83 62
64 145 169 56 53
128 198 181 48 57
256 191 178 44 58
512 196 180 27 32
1024 189 180 22 26
4096 193 181 19 23
16384 195 177 19 22
65536 186 166 19 22
Total Elapsed Time 49.0 seconds
System T2, ARM Cortex-A9 800 MHz, Android 2.3.4
Android RandMem Benchmark 20-Feb-2012 16.45
MBytes/Second transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 1777 1879 1669 1809
32 1359 1394 1185 1505
64 799 861 621 755
128 394 202 295 333
256 147 146 92 104
512 133 136 71 42
1024 125 125 53 62
4096 129 98 41 53
16384 128 113 42 45
65536 121 115 30 32
Total Elapsed Time 15.7 seconds
System T4, ARM Cortex-A9 1500 MHz, Android 4.0.3
Measured 1200 MHz
Android RandMem Benchmark 11-May-2012 17.19
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 2777 3014 2671 3021 L1
32 2254 2490 2062 2561
64 872 1109 875 998 L2
128 797 870 674 721
256 807 932 528 560
512 543 465 186 182
1024 388 241 78 83 RAM
4096 367 229 56 48
16384 366 229 48 45
65536 335 228 41 38
Total Elapsed Time 13.2 seconds
T7, ARM Cortex-A9 1300 MHz, Android 4.1.2,
Measured 1200 MHz
Android RandMem Benchmark 20-Oct-2012 11.14
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 2788 3041 2795 3041 L1
32 2769 3011 2767 3020
64 1027 1038 839 911 L2
128 916 918 616 649
256 904 905 514 538
512 899 907 475 499
1024 712 699 345 354
4096 323 284 92 88 RAM
16384 316 282 73 70
65536 314 281 65 62
Total Elapsed Time 10.9 seconds
T6, ARM Cortex-A9 1600 MHz, Android 4.0.3, DDR3 RAM
Android RandMem Benchmark 26-Aug-2012 13.58
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 3925 4257 3881 4275 L1
32 3867 4204 3864 3998
64 1276 1284 1042 1182 L2
128 1126 1133 775 844
256 1118 1121 641 706
512 1107 1113 584 655
1024 750 715 352 366
4096 362 314 103 97 RAM
16384 337 317 84 79
65536 369 317 75 71
Total Elapsed Time 10.3 seconds
T8 Allwinner A13-MID, 1 GHz ARM Cortex-A8
Android RandMem Benchmark 1.1 05-Mar-2013 10.03
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 2032 2787 2057 2802 L1
32 2014 2736 1972 2668
64 458 309 92 141 L2
128 423 316 74 121
256 304 204 39 58 RAM
512 270 201 29 36
1024 267 192 27 39
4096 258 197 23 35
16384 247 206 22 34
65536 254 206 19 28
Total Elapsed Time 20.7 seconds
T11 Samsung EXYNOS 5250 2.0 GHz Cortex-A15, Android 4.2.2
Measured 1.7 GHz
Android RandMem Benchmark 1.1 13-Aug-2013 17.29
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 2881 2478 3388 3650
32 4301 2968 3197 3249
64 3669 2511 2201 2249
128 3566 2560 1571 1566
256 3557 2461 1334 1256
512 3524 2547 1136 1098
1024 1933 1144 534 513
4096 1993 1064 184 173
16384 1970 1086 141 144
65536 1973 1117 106 104
Total Elapsed Time 9.1 seconds
P11, ARM Cortex-A9 1.4 GHz, Android 4.0.4
Android RandMem Benchmark 23-Dec-2012 15.18
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 3253 3542 3255 3438 L1
32 2626 2794 2511 2945
64 1453 1471 1298 1467 L2
128 1298 1302 1030 1095
256 1279 1289 819 826
512 1054 1075 237 245
1024 1155 989 150 146
4096 1101 919 107 106 RAM
16384 1061 911 91 90
65536 1048 919 73 77
Total Elapsed Time 10.7 seconds
P10 Qualcomm Snapdragon, 1.5 GHz, Android 4.0.3, DDR2
Android RandMem Benchmark 25-Sep-2012 09.02
MBytes/Second Transferring 4 Byte Words
Memory Serial....... Random.......
KBytes Read Rd/Wrt Read Rd/Wrt
16 1878 3732 2564 3081 L1
32 1545 1796 1258 1487 L2
64 1472 1797 1030 1205
128 1502 1769 869 1084
256 1548 1786 795 938
512 1323 1264 604 798
1024 745 697 230 268
4096 425 457 149 145 RAM
16384 481 458 120 130
65536 501 458 100 106
Total Elapsed Time 10.2 seconds
Atom 1666 MHz, DDR2 RAM 800 MHz, Linux
16 3976 5132 4100 5134
64 3086 3215 1042 1349
65536 2708 1290 49 74
|
DriveSpeed and
DriveSpeed2 Benchmarks Primarily to measuring performance of SD cards and internal drives, DriveSpeed carries out four tests.
Test 1 - Write and read three 8 and 16 MB; Results given in MBytes/second
Test 2 - Write 8 MB, read can be cached in RAM; Results given in MBytes/second
Test 3 - Random write and read 1 KB from 4 to 16 MB; Results are Average time in milliseconds
Test 4 - Write and read 200 files 4 KB to 16 KB; Results in MB/sec, msecs/file and delete seconds.
DriveSpeed was produced for early Android systems that had an internal drive and an external SD card. These were identified by specific programming functions and executed via two buttons RunI and RunS. The general form was that RunS used direct I/O, avoiding data being cached in RAM. but RunI used cached data. A More button was provided for the latter with choices of Don’t Delete and/or Read Only, allowing reading speed to be measured after rebooting. This is still available but has an added display to identify drive capacity and free space, helping to identify the drive/card used. The directory path for the device used is also shown.
With later versions of Android or system hardware, the internal drive could have the largest part operating as an SD drive and the remainder as a cached drive. The directory path used was also found to vary on different systems. DriveSpeed2 starts with an input request to type in the path. This can normally be found via a FileBrowser app. Then there are Run and Restart buttons, the latter to correct a false entry or to select a different drive. There is also a Save button to Email results (to me or/and whoever). These new procedures also allowed USB connected devices to be selected (in some cases).
The benchmark can be downloaded from the links
DriveSpeed
and
DriveSpeed2.
Below are examples of results. These include the usual configuration details (see above). Drive capacity and paths used for later example results are also provided.
|
The benchmark is a subset of a version produced for PCs, the Windows version drivespeed32.exe, found in drivespeed32.zip, with drivespeed32 and drivespeed64, Linux varieties, from this tar.gz file. The execution files can be copied to to Android drives and executed on a PC via a USB connection. Details and results on a range of systems are provided in linux_disk_usb_lan_benchmarks.htm. Here, device "Sig" id the same USB stick as USBS1 below and is extremely slow on writing small files and deleting them via Windows. This is a Windows problem associated with too frequent updates of the File Allocation Table, under FAT formatting.
Large Files - The speed of large files on internal drives has been slow, compared with PC hard drives, but that on tablet T11 shows an improvement, where reading speeds can be 50 MB/second. However, SD4, the super fast SD card does not perform well as an external card. T11 also has a USB 3 connector, where reading speed can sometimes be similar to the internal drive but, in both cases, writing speed is disappointing.
Small Files - In the case of Sig, mentioned above, minimum time to write small files via Windows was around 300 milliseconds, but more modern memory can produce similar speeds to Android. For example, SD4 minimum time is around 17 milliseconds using the Windows version (USB2). This is still excessive as hard drives can have a minimum of 0.5 milliseconds.
Cached Files - These are where Android is allowed to keep a copy of the data in main memory. Here, writing speeds can vary considerably, from just writing to memory, to saving to the drive. Reading performance can reflect memory speed.
Random Access - As shown in
Linux Results,
random writing speeds can be subject to extremely wide variations on flash drives, and random reading times can be less than on disk drives that are subject to rotational delays. Disk random reading speeds can be faster on small files, as the data is cached in a buffer.
|
MultiThreading BenchmarksSome of these benchmarks produce poor performance, influenced by Power Saving options and short running time. For versions that run for extended periods see Android Long MP Benchmarks.htm.
MP-MFLOPS - measures floating point speed on data from caches and RAM. The arithmetic operations executed are of the form x[i] = (x[i] + a) * b - (x[i] + c) * d + (x[i] + e) * f with 2 and 32 operations per input data word. Data sizes are also limited to three to use L1 cache, L2 cache and RAM at 12.8, 128 and 12800 KB (3200, 32000 and 3200000 single precision floating point words). The program is run using 1, 2, 4 and 8 threads.
MP-Whetstone - Multiple threads each run the eight test functions at the same time, but with some dedicated variables. Measured speed is based on the last thread to finish, with Mutex functions, used to avoid the updating conflict by only allowing one thread at a time to access common data. Again performance is generally proportional to the number of cores used. Floating point speeds and the overall rating, using one thread, are similar to the single CPU version, but integer calculations are slower for some reason.
MP-Dhrystone - This runs multiple copies of the whole program at the same time. Dedicated data arrays are used for each thread but there are numerous other variables that are shared. The latter reduces performance gains via multiple threads (example - 2 threads 1.8 x speed). Single thread results are also slightly slower than the normal benchmark.
MP-BusSpeed - This runs integer read only tests using caches and RAM, each thread accessing the same data sequentially. Performance gains, using L1 cache, can be proportional to the number of cores, but not quite so using L2. The program is designed to produce maximum throughput over buses and demonstrates the fastest RAM speeds using multiple cores.
MP-RandMem - The benchmark has cache and RAM read only and read/write tests using sequential and random access, each thread accessing the same data but starting at different points. It uses the Mutex functions as in Whetstone above. Performance characteristics tend to be constant on a particular system but can be unpredictable, like slower speed using a higher number of threads. On a dual core CPU, there were reasonable gains (1.7x) on serial reading but none elsewhere. A quad core processor showed no gains at all, resulting in certain tests being slower than the dual core system.
NEON BenchmarksSome of the benchmarks have been converted to use NEON Single Instruction Multiple Data (SIMD) instructions, using special ARM intrinsic functions. In this case, operating on four 32 bit numbers at the same time. These SIMD instructions are equivalent to Intel SSE and AMD 3DNow instructions. For details and results see www.roylongbottom.org.uk/Android NEON Benchmarks.htm.
NeonSpeed - This benchmark carries out the same calculations as MemSpeed single precision floating point and integer tests, using caches and RAM. MemSpeed normal calculations are carried out besides the same ones using NEON functions. The latter can be more than three times faster.
NEON MP MFLOPS - This is the same as MP-MFLOPS benchmark above, except, in this case, the operational sequences are generated by NEON Intrinsic Functions.
NEON Linpack - This is the same as the single precision version of the Linpack 100 Benchmark, described above, except NEON intrisic functions are used for the key calculations.
NEON Linpack MP - This version uses mainly the same C programming code as the single precision floating point NEON compilation above. It is run run on 100x100, 500x500 and 1000x1000 matrices using 0, 1, 2 and 4 separate threads. The 0 thread procedures are identical to above. The initial 100x100 Linpack benchmark is only of use for measuring performance of single processor systems. The one for shared memory multiple processor systems is a 1000x1000 variety. The programming code for this is the same as 100x100, except users are allowed to use their own linear equation solver. Unlike the NEON MP MFLOPS benchmark, that carries out the same multiply/add calculations, this program can run much slower using multiple threads. This is due to the overhead of creating and closing threads too frequently, relative to calculation time.
Graphics BenchmarksJavaOpenGL1 -
This benchmark does not rely on complex visual scenes or mathematical functions. The objective being to generate moderate to excessive loading via multiple simple objects. It uses all Java code, with OpenGL ES GL10 statements, to measure graphics performance in Frames Per Second (FPS). Four tests draw a background of 50 cubes first as wireframes then colour shaded. The third test views the cubes in and out of a tunnel with slotted sides and roof, also containing rotating plates. The last test adds textures to the cubes and plates. The 50 cubes are redrawn 15, 30 and 60 times, with randomised positions, colours rotational settings. With 6 x 2 triangles per cube, minimum triangles per frame for the three sets of tests are 9000, 18000 and 36000.
Details and results can be found in
Android Graphics Benchmarks.
Measure CPU MHzThe procedure to use is to load a benchmark then load CPU_MHz, forcing the benchmark into the background. Start the CPU_MHz program, switch the benchmark into foreground and start that. The method for switching apps is not the same on all devices, so you will have to look it up (latest is to press multi-task bottom on-screen button).
Following shows results, measuring MHz whilst running MemSpeed Benchmark, whose results were proportional to MHz.
For comparative benchmarking, running continuously at maximum MHz is desirable.
##################################################
T11 Samsung EXYNOS 5250 2.0 GHz Cortex-A15, Android 4.2.2
Energy Saving Off
MemSpeed Total Elapsed Time 10.9 seconds
Android Java CPU MHz 13-Aug-2013 16:55:50
0.00 1000 1.02 1000
2.08 1000 3.11 1000
4.16 1000 5.18 1000
6.24 1000 7.29 1000
8.32 1700 9.34 1200
10.35 1700 11.36 1700
12.38 1700 13.40 1700
14.42 1700 15.45 1700
16.48 1700 17.50 1700
18.54 1000 19.59 1000
20.64 1000 21.67 1000
22.72 1000 23.76 1000
24.82 1000 25.87 1000
26.93 1000 27.98 1000
29.04 1000 30.08 1000
Running Finished 13-Aug-2013 16:56:22
Energy Saving On
MemSpeed Total Elapsed Time 11.9 seconds
Android Java CPU MHz 14-Aug-2013 11:12:55
0.00 1000 1.02 1000
2.05 1000 3.08 1000
4.11 1000 5.14 1000
6.20 1000 7.23 1000
8.24 1000 9.26 1000
10.28 1000 11.30 1000
12.32 1000 13.34 1000
14.36 1000 15.40 1000
16.43 1000 17.46 1000
18.49 1000 19.52 1000
20.56 1000 21.59 1000
22.62 1000 23.65 200
24.72 1000 25.76 1000
26.80 1000 27.83 1000
28.89 1000 29.92 1000
Running Finished 14-Aug-2013 11:13:26
##################################################
T7 ARM Cortex-A9 1300 MHz, Android 4.1.2
Battery Power
MemSpeed Total Elapsed Time 11.7 seconds
Android Java CPU MHz 14-Aug-2013 09:11:23
0.00 1000 1.03 475
2.06 760 3.09 1300
4.13 1300 5.17 1300
6.31 640 7.34 1200
8.36 1200 9.37 1200
10.39 1200 11.40 1200
12.42 1200 13.43 1200
14.45 1200 15.47 1200
16.49 1200 17.51 1200
18.53 1200 19.57 1000
20.60 760 21.62 1200
22.66 760 23.68 475
24.71 1300 25.74 475
26.78 475 27.82 475
28.85 475 29.89 475
Running Finished 14-Aug-2013 09:11:54
##################################################
T4 ARM Cortex-A9 1500 MHz, Android 4.0.3
CPU Development Performance Setting
MemSpeed Total Elapsed Time 13.0 seconds
Android Java CPU MHz 14-Aug-2013 16:26:27
0.00 1200 1.02 1200
2.04 1200 3.06 1200
4.07 1200 5.09 1200
6.12 1200 7.13 1200
8.15 1200 9.17 1200
10.18 1200 11.20 1200
12.22 1200 13.25 1200
14.27 1200 15.30 1200
16.32 1200 17.34 1200
18.37 1200 19.40 1200
20.44 1200 21.46 1200
22.47 1200 23.49 1200
24.51 1200 25.52 1200
26.54 1200 27.56 1200
28.61 1200 29.63 1200
Running Finished 14-Aug-2013 16:26:58
CPU Development Normal MHz Setting
MemSpeed Total Elapsed Time 13.6 seconds
Android Java CPU MHz 14-Aug-2013 16:21:44
0.01 288 1.08 192
2.16 192 3.25 96
4.42 192 5.66 288
6.71 288 7.84 192
8.93 384 9.97 864
10.99 1200 12.01 1200
13.03 1200 14.05 1200
15.07 1200 16.10 1200
17.12 1200 18.14 1200
19.17 1200 20.20 1200
21.22 1200 22.24 1104
23.26 720 24.29 336
25.34 144 26.46 144
27.57 144 28.69 144
29.81 144 30.92 144
Running Finished 14-Aug-2013 16:22:16
|
Three of the tests provided, load and display image files, each of around one million bytes, but producing different numbers of pixels to display. Format of these files are uncompressed BMP, compressed GIF and compressed JPG. A further test loads 400 different GIF icons, each sized approximately 70 Bytes. These functions, using Java script, are copied from another HTML file, for use here, as they have been found to work on Android based devices, but in some strange ways. That HTML document also runs the Whetstone benchmark via Java Applets, but these do not run using Android.
When images are loaded, they can be saved in the browser’s cache on the local device disk. On resubmitting the image page address, or selecting Refresh, the images are likely to be loaded from the cache at high speed. This is generally avoided by loading via a .htm file, renamed as .php, with the time added to the file name, for example using
<img src="gif1m.gif?<? echo time(); ?>">.
Note that the measured time is less than the actual time taken, typically by up to 1.5 seconds, but can be closer on selecting Refresh. Below are results, based on at least three measurements on the same broadband connection, where maximum speed is normally around 10 Mbps. So, it is likely that minimum loading of the 1 MB files will be greater than one second. For reference, results using Windows and Linux are also provided. These showed that Linux and Firefox was generally faster than Windows with Internet Explorer but Firefox did not help via Windows.
Initial loading times on Android tablet T2 were really slow, using the default browser. Opera, with high speed claims, was installed but only managed to speed up loading times of the small GIF files. T1 tablet, with the older CPU, provided some faster results than PCs with Windows, but failed to display the 1 MB GIF file.
A broadband speed tester confirmed the slow T2 speed at 0.6 Mbps whilst a Linux desktop PC produced 8.5 Mbps.
Loading Time Seconds
MHz OS 1 MB BMP 1 MB GIF 1 MB JPG 400 GIF
Wireless
Tablet T1 ARM 926EJ 800 Android 2.2 2.5-2.8 2.5-2.6# 2.3-2.7 6.5-7.4
Tablet T2 ARM v7-A9 800 Android 2.3.4 13.8-14.4 12.9-14.3 13.4-14.8 11.4-12.3
Tablet T2 ARM v7-A9 800 Andr 2.3.4 OP 13.5-14.3 13.0-14.8 13.2-13.7 5.5-6.0
Tablet T4 ARM v7-A9 1500 Android 4.0.3 2.0-2.3 2.1-2.5 2.0-2.4 3.9-5.2
Netbook Atom 1666 WinXP IE 5.5-5.8 2.5-4.1 2.6-3.2 7.4-8.0*
Netbook Atom 1666 Abuntu FF 1.1-2.3 1.1-2.2 1.2-2.6 4.6-6.6
Laptop Core 2 1833 Win Vista IE 3.3-3.7 3.2-3.4 3.4-3.6 20.7-22.6
Laptop Core 2 1833 Abuntu FF 1.4-2.4 1.3-1.3 1.2-1.8 4.9-5.2
Wired
Desktop 1 Core 2 1600 Abuntu FF 2.2-2.7 1.8-2.9 1.8-1.9 4.6-4.6
Desktop 1 Core 2 2400 Abuntu FF 1.9-2.3 1.1-1.4 1.2-1.4 4.6-4.6
Desktop 2 Phenom 3000 Win 7 IE 2.5-4.3 2.4-3.0 2.4-2.5 4.7-4.8
Desktop 2 Phenom 3000 Win 7 FF 2.4-2.7 2.5-3.0 3.5-2.7 5.3-6.1
Desktop 2 Phenom 3000 Win 7 GC 2.3-2.7 2.5-3.0 2.5-2.6 5.1-6.1
|
BlueStacks is an Android App Player that runs under Windows, downloadable (free October 2012) from www.bluestacks.com. The package allocates an icon to any .apk files on a PC. A right click on these gives an option to Open with BlueStacks APP Installer. A download from Internet saves the files on an imaginary SD card and they can be installed from there.
I installed the app on a 64-Bit Windows 7 PC with a 3 GHz quad core Phenom CPU and a 1.83 GHz Core 2 Duo based laptop under 32-Bit Windows Vista. It failed to install via 64-Bit Vista (needed unselectable Administrator approval) and Windows XP (needed something from SP3).
The Systems Used are identified below as BS1 and BS2 and some results are included above. Typically, NDK pre-compiled C/C++ benchmark code, using BlueStacks on a 3 GHz PC, runs at 5% of the speed of Windows versions or 10% of a 1.5 GHz Cortex-A9 tablet CPU. On the other hand, Java benchmarks can run at the same speed as the 1.5 GHz tablet and
much faster speeds can be obtained using RAM sized data - see
BusSpeed Benchmark above.
I had a go at installing Android on a PC to run some of my new benchmarks. First attempt was to download the ISO for an Android 4.0 variety, but that did not work. Second was generic_x86-20120611.iso (Android 2.2.1, Linux 2.6.35.7). This was burnt to a DVD, tested as live then installed on a USB stick (on a laptop using a Core 2 Duo with hard disk removed). The USB stick booted with Internet accessible via a LAN but WiFi would not connect. Keyboard worked OK, along with mouse left, centre and right button functions. I then found that I could not download my Java Apps. With a bit of luck I found that this was because I had opted to install on the existing drive FAT format, where saving is inhibited.
Next I opted for Ext3 formatting and, before restarting, I found that I could download and run my Java Apps, set up Email and post the results. Then I found that the USB stick would not boot. After several goes at pre-formatting and installing (takes little time), I found that it booted on two desktops (Core 2 DUO and Phenom) and on my Atom based Netbook but not on the Core 2 laptop.
The benchmarks run on these systems were Java Whetstone and Linpack benchmarks, but they are relatively slow, probably due to an inefficient Java Runtime Environment. Details are included above in Java Whetstone Benchmark Results and Java Linpack Results (see And x86).
Using the same programming functions, system information obtained is different running under Android x86. Some details are provided below.
Atom Android Build Version 2.2.1 bogomips : 3406.65 address sizes : 32 bits physical, 48 bits virtual processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 28 model name : Intel(R) Atom(TM) CPU N455 @ 1.66GHz stepping : 10 cpu MHz : 1667.000 cache size : 512 KB cpu cores : 1 Linux version 2.6.35.7-android-x86+ (root@afro) (gcc version 4.3.2 (Debian 4.3.2-1.1) ) #1 SMP PREEMPT Sun Feb 20 00:23:02 CET 2011 Core 2 Duo Android Build Version 2.2.1 bogomips : 4779.78 address sizes : 36 bits physical, 48 bits virtual processor : 1 vendor_id : GenuineIntel cpu family : 6 model : 15 model name : Intel(R) Core(TM)2 CPU 6600 @ 2.40GHz stepping : 6 cpu MHz : 2394.000 cache size : 4096 KB cpu cores : 2 Linux version 2.6.35.7-android-x86+ (root@afro) (gcc version 4.3.2 (Debian 4.3.2-1.1) ) #1 SMP PREEMPT Sun Feb 20 00:23:02 CET 2011 |
T1 Device TTFone M013S 10.1 inch tablet, 300-800 MHz VIA 8650
Screen pixels w x h 600 x 1024
Android Build Version 2.2
Processor : ARM926EJ-S rev 5 (v5l)
BogoMIPS : 797.97
Features : swp half thumb fastmult edsp java
CPU part : 0x926
Linux version 2.6.32.9
T2 Device WayTeq xTAB-70 7 inch tablet, 800 MHz Cortex-A9
Screen pixels w x h 600 x 800
Android Build Version 2.3.4
Processor : ARMv7 Processor rev 1 (v7l)
BogoMIPS : 2035.71
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0xc09 - Cortex-A9
Linux version 2.6.34
T3 Device Samsung P7500
Screen pixels w x h 1280 x 752
Android Build Version 3.2
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 BogoMIPS : 1998.84
processor : 1 BogoMIPS : 1998.84
Features : swp half thumb fastmult vfp edsp vfpv3 vfpv3d16
CPU part : 0xc09 - Cortex-A9
Linux version 2.6.36.3
T4 Device Miumiu w17 Pro 7 inch tablet, dual 1500 MHz Cortex-A9
Screen pixels w x h 600 x 976
Android Build Version 4.0.3 - Ice Cream Sandwich
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 BogoMIPS : 2393.70
processor : 1 BogoMIPS : 2393.70
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0xc09 - Cortex-A9
Hardware : Amlogic Meson6 g04 customer platform
Linux version 3.0.8
T5 Device Ainol Novo 7 Paladin Tablet, 1 GHz MIPS CPU, ARM emulation
Screen pixels w x h 480 x 800
Android Build Version 4.0.1
system type : JZ4770
processor : MIPS-compatible processor JZ4770
cpu model : Ingenic Xburst
BogoMIPS : 1005.97
Features : fpu mxu dsp lowpower
CPU implementer : Ingenic
CPU architecture : MIPS
Hardware : npm702
Linux version 2.6.32.9
T6 Device Asus Transformer TF700
Screen pixels w x h 1920 x 1128
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 9 (v7l)
processor : 0 BogoMIPS : 1993.93
processor : 1 BogoMIPS : 1993.93
processor : 2 BogoMIPS : 1993.93
processor : 3 BogoMIPS : 1993.93
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x2
CPU part : 0xc09 - Cortex-A9
CPU revision : 9
Hardware : cardhu - nVidia Tegra 3
Linux version 2.6.39.4
T7 Device Google Nexus 7 quad core CPU 1.3, GHz 1.2 GHz > 1 core
RAM 1 GB DDR3L-1333 Bandwidth 5.3 GB/sec
Screen pixels w x h 1280 x 736 MHz
Twelve-core Nvidia GeForce ULP graphics 416 MHz
Android Build Version 4.1.2
Processor : ARMv7 Processor rev 9 (v7l)
processor : 0 BogoMIPS : 1993.93
processor : 1 BogoMIPS : 1993.93
processor : 2 BogoMIPS : 1993.93
processor : 3 BogoMIPS : 1993.93
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x2
CPU part : 0xc09 - Cortex-A9
CPU revision : 9
Hardware : grouper - nVidia Tegra 3 T30L
Revision : 0000
Linux version 3.1.10
T8 Allwinner A13-MID, 1 GHz ARM Cortex-A8
Internal Drive MB 1007 Free 917
SD Card MB 5455 Free 4575
Screen pixels w x h 800 x 432
Android Build Version 4.0.4
Processor : ARMv7 Processor rev 2 (v7l)
BogoMIPS : 1001.88
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x3
CPU part : 0xc08
CPU revision : 2
Hardware : sun5i
Revision : 0000
Linux version 3.0.8
T9 Device WM8650 800 MHz
Screen pixels w x h 800 x 480
Android Build Version 2.2
Processor : ARM926EJ-S rev 5 (v5l)
BogoMIPS : 797.97
Features : swp half thumb fastmult edsp java
CPU implementer : 0x41
CPU architecture: 5TEJ
CPU variant : 0x0
CPU part : 0x926
Hardware : WMT
Linux version 2.6.32.9
T11 Voyo A15, Samsung EXYNOS 5250 Dual core 2.0 GHz Cortex-A15,
Mali-T604 GPU, 2 GB DDR3-1600 RAM, dual channel, 12.8 GB/s
Screen pixels w x h 1920 x 1032
Android Build Version 4.2.2 - Jelly Bean
Processor : ARMv7 Processor rev 4 (v7l)
processor : 0
BogoMIPS : 992.87
processor : 1
BogoMIPS : 997.78
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls vfpv4
idiva idivt
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x0
CPU part : 0xc0f
CPU revision : 4
Hardware : SMDK5250
Linux version 3.4.35Ut
T12 Samsung GaIaxy Note 2, Quad core 1.6 GHz Cortex-A9
Screen pixels w x h 720 x 1280
Android Build Version 4.1.2
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 BogoMIPS : 1592.52
processor : 2 BogoMIPS : 2189.72
processor : 3 BogoMIPS : 2189.72
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x3
CPU part : 0xc09
CPU revision : 0
Chip revision : 0020
Hardware : SMDK4x12
Revision : 000b
Linux version 3.0.31
T13 Samsung Galaxy Note 1 Dual Core 1.4 GHz Cortex-A9
Screen pixels w x h 800 x 1280
Android Build Version 4.1.2
Processor : ARMv7 Processor rev 1 (v7l)
processor : 0 BogoMIPS : 1592.52
processor : 1 BogoMIPS : 1990.65
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x2
CPU part : 0xc09
CPU revision : 1
Hardware : SMDK4210
Revision : 0008
Linux version 3.0.31
P1 Device Motorola Milestone 1 CyanogenMod 7 ROM overclocked
Screen pixels w x h 854 x 480
Android Build Version 2.3.5
Processor : ARMv7 Processor rev 3 (v7l)
BogoMIPS : 598.90
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0xc08 - Cortex-A8
Linux version 2.6.32.9
P2 Device Samsung Galaxy s
Screen pixels w x h 480 x 800
Android Build Version 2.2
Processor : ARMv7 Processor rev 2 (v7l)
BogoMIPS : 996.00
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0xc08 - Cortex-A8
Linux version 2.6.32.9
P3 Device Motorola Milestone 3 (XT860)
Screen pixels w x h 960 x 540
Android Build Version 2.3.6
Processor : ARMv7 Processor rev 2 (v7l)
processor : 0 - CPU 1 of 2
BogoMIPS : 598.90 - too low?
Features : swp half thumb fastmult vfp edsp thumbee neon vfpv3
CPU part : 0xc09 - Cortex-A9
Linux version 2.6.35.7
P4 Device Huawei u8800 - 800 MHz Scorpion CPU - Cortex-A8
Screen pixels w x h 480 x 800
Android Build Version 2.3.5
Processor : ARMv7 Processor rev 1 (v7l)
BogoMIPS : 537.39
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0x00f
Hardware : HUAWEI U8800 BOARD
Linux version 2.6.35.7
P5 Device HTC One X - Quad Core
Screen pixels w x h 720 x 1184
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 9 (v7l4
processor : 0 - CPU 1 of 4
BogoMIPS : 1993.93
Features : swp half thumb fastmult vfp edsp neon vfpv3
CPU part : 0xc09 - Cortex-A9
Hardware : endeavoru
Linux version 2.6.39.4
P6 Qualcomm Snapdragon S4, 1500 MHz, 1 GB DDR2 RAM
Device HTC One S Ville - Dual Core
CPU MSM8260A? see P8 HTC One S MSM8960
Screen pixels w x h 540 x 888
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0
BogoMIPS : 13.53
processor : 1
BogoMIPS : 13.53
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x51
CPU architecture: 7
CPU variant : 0x1
CPU part : 0x04d
CPU revision : 0
Hardware : ville
Revision : 0080
Linux version 3.0.8-
P7? Device not given. [Evidence suggests Marvell technology
e.g. Marvell's Brownstone Development Platform and
Marvell - PJ4Bv7 CPU with CPU implementer :0x56,
architecture: 7, CPU part :0x584, rev 2]
Screen pixels w x h 1280 x 752
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 BogoMIPS : 831.32
processor : 1 BogoMIPS : 834.00
Features: swp half thumb fastmult vfp edsp iwmmxt thumbee neon vfpv3
CPU implementer : 0x56
CPU architecture: 7
CPU variant : 0x2
CPU part : 0x584
CPU revision : 0
Hardware : Brownstone2x
Revision : 0000
Linux version 3.0.8, (Marvell GCC 201201)
P8 Qualcomm Snapdragon S4, 1500 MHz, 1 GB dual channel RAM
Device HTC One S - Dual Core
CPU MSM8960 see P6 HTC One S MSM8260A?
Screen pixels w x h 540 x 888
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0
BogoMIPS : 13.53
processor : 1
BogoMIPS : 13.53
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls vfpv4
CPU implementer : 0x51
CPU architecture: 7
CPU variant : 0x1
CPU part : 0x04d
CPU revision : 0
Hardware : QCT MSM8960 CDP
Revision : 0000
Linux version 3.0.8
P9 Device Samsung Galaxy s Captivate
Screen pixels w x h 480 x 800
Android Build Version 2.3.5
Processor : ARMv7 Processor rev 2 (v7l)
BogoMIPS : 996.00
Features : swp half thumb fastmult vfp edsp thumbee neon vfpv3
CPU part : 0xc08 - Cortex-A8
Linux version 2.6.35.7
P10 Qualcomm Snapdragon S4, 1500 MHz, 1 GB dual channel RAM
Device HTC One X - Dual Core
CPU MSM8960
Screen pixels w x h 720 x 1184
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0
BogoMIPS : 13.53
processor : 1
BogoMIPS : 13.53
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x51
CPU architecture: 7
CPU variant : 0x1
CPU part : 0x04d
CPU revision : 0
Hardware : elite
Revision : 0080
Linux version 3.0.8
P11 Samsung Galaxy SIII, Quad Core 1.4 GHz Cortex-A9
Dual Channel DDR2 RAM
Screen pixels w x h 720 x 1280
Android Build Version 4.0.4
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 BogoMIPS : 1592.52
processor : 1 BogoMIPS : 2786.91
processor : 3 BogoMIPS : 398.13
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x3
CPU part : 0xc09
CPU revision : 0
Hardware : SMDK4x12
Revision : 000c
Serial : 3b065f3d4df1bb2d
Linux version 3.0.15
P13 Samsung Galaxy GT-I9100 SII Dual core 1.2 GHz Cortex-A9
Screen pixels w x h 480 x 800
Android Build Version 4.1.2
Processor : ARMv7 Processor rev 1 (v7l)
processor : 0
BogoMIPS : 1592.52
processor : 1
BogoMIPS : 2388.78
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x2
CPU part : 0xc09
CPU revision : 1
Hardware : SHW-M250K
Revision : 000a
Linux version 3.0.31
P14 Hawaii? Dual Core Cortex-A9
Screen pixels w x h 540 x 888
Android Build Version 4.2.1
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0
BogoMIPS : 2000.48
processor : 1
BogoMIPS : 2000.48
Features : swp half thumb fastmult vfp edsp neon vfpv3 tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x3
CPU part : 0xc09
CPU revision : 0
Hardware : hawaii
Revision : 0000
Linux version 3.4.5
P16 LG G2X 512 MB Dual-channel RAM Dual-core Cortex-A9 1 GHz
Screen pixels w x h 480 x 800
Android Build Version 2.3.4
Processor : ARMv7 Processor rev 0 (v7l)
processor : 0 and 1 BogoMIPS : 1998.84
Features : swp half thumb fastmult vfp edsp vfpv3 vfpv3d16
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x1
CPU part : 0xc09
CPU revision : 0
Hardware : Tegra 2 Development System
Linux version 2.6.32
EP1 Device Emulator 3 GHz Phenom
or 2.4 GHz Core 2
Screen pixels w x h 240 x 320
Android Build Version 2.2
Processor : ARM926EJ-S rev 5 (v5l)
BogoMIPS : 522.64
Linux version 2.6.29
ET1 Device Emulator 3 GHz Phenom
Screen pixels w x h 600 x 1024
Android Build Version 2.2
Processor : ARM926EJ-S rev 5 (v5l)
BogoMIPS : 530.84
Linux version 2.6.29
ET2 Device Emulator 3 GHz Phenom
or 2.4 GHz Core 2
Screen pixels w x h 600 x 1024
Android Build Version 4.0.3
Processor : ARMv7 Processor rev 0 (v7l)
BogoMIPS : 527.56
Linux version 2.6.29
BS1 BlueStacks Emulator on 3 GHz Phenom
Screen pixels w x h 1024 x 600
Android Build Version 2.3.4
processor : 0
vendor_id : AuthenticAMD
cpu family : 16
model : 4
model name : AMD Phenom(tm) II X4 945 Processor
stepping : 2
cpu MHz : 3013.000
cache size : 512 KB
-
-
bogomips : 26686.25
Linux version 2.6.38
BS2 BlueStacks Emulator on 1.83 GHz Core 2 Duo
Screen pixels w x h 1024 x 600
Android Build Version 2.3.4
processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 15
model name : Intel(R) Core(TM)2 Duo CPU T5550 @ 1.83GHz
stepping : 13
cpu MHz : 1828.000
cache size : 2048 KB
-
-
bogomips : 12294.55
Linux version 2.6.38
|